package lin

import (
	"encoding/json"
	"errors"
	"sort"
	"strings"

	"sync"
	"time"
)

type S数组_文本 struct {
	原始数据 []string
	读写许可 *sync.RWMutex
}

func (类 *S数组_文本) 初始化() {
	if 类.原始数据 == nil {
		类.原始数据 = make([]string, 0)
	}
}
func (类 *S数组_文本) ZX置线程安全() {
	if 类.读写许可 == nil {
		var 锁 sync.RWMutex
		类.读写许可 = &锁
	}
}

// @ 支持 json && []any && []W文本数组 && L列表 &&[]基本类型 && 可以json化的切片
func (类 *S数组_文本) ZR载入(载入值 any) (返回_错误 error) {
	if 类.读写许可 != nil {
		类.读写许可.Lock()
		defer 类.读写许可.Unlock()
	}
	类.原始数据 = make([]string, 0)
	switch 当前值 := 载入值.(type) {
	case string:
		返回_错误 = json.Unmarshal([]byte(当前值), &类.原始数据)
		return
	case []any:
		for _, v := range 当前值 {
			类.原始数据 = append(类.原始数据, any_到文本(v))
		}
		return
	case S数组_文本:
		if &类.原始数据 == &当前值.原始数据 {
			返回_错误 = errors.New("错误:自己不能载入自己")
			return
		}
		类.原始数据 = 当前值.Q取切片()
		return
	case L列表:
		值组 := 当前值.D到切片()
		for _, v := range 值组 {
			类.原始数据 = append(类.原始数据, any_到文本(v))
		}
		return
	case []int:
		for _, v := range 当前值 {
			类.原始数据 = append(类.原始数据, any_到文本(v))
		}
		return
	case []bool:
		for _, v := range 当前值 {
			类.原始数据 = append(类.原始数据, any_到文本(v))
		}
		return
	case []float64:
		for _, v := range 当前值 {
			类.原始数据 = append(类.原始数据, any_到文本(v))
		}
		return
	case []float32:
		for _, v := range 当前值 {
			类.原始数据 = append(类.原始数据, any_到文本(v))
		}
		return
	case []int8:
		for _, v := range 当前值 {
			类.原始数据 = append(类.原始数据, any_到文本(v))
		}
		return
	case []int16:
		for _, v := range 当前值 {
			类.原始数据 = append(类.原始数据, any_到文本(v))
		}
		return
	case []int32:
		for _, v := range 当前值 {
			类.原始数据 = append(类.原始数据, any_到文本(v))
		}
		return
	case []int64:
		for _, v := range 当前值 {
			类.原始数据 = append(类.原始数据, any_到文本(v))
		}
		return
	case []uint:
		for _, v := range 当前值 {
			类.原始数据 = append(类.原始数据, any_到文本(v))
		}
		return
	case []uint16:
		for _, v := range 当前值 {
			类.原始数据 = append(类.原始数据, any_到文本(v))
		}
		return
	case []uint32:
		for _, v := range 当前值 {
			类.原始数据 = append(类.原始数据, any_到文本(v))
		}
		return
	case []uint64:
		for _, v := range 当前值 {
			类.原始数据 = append(类.原始数据, any_到文本(v))
		}
		return
	case []byte:
		for _, v := range 当前值 {
			类.原始数据 = append(类.原始数据, any_到文本(v))
		}
		return
	case []time.Time:
		for _, v := range 当前值 {
			类.原始数据 = append(类.原始数据, any_到文本(v))
		}
		return
	case []string:
		类.原始数据 = append(类.原始数据, 当前值...)
		return
	default:
		JSON, err := json.Marshal(载入值)
		if err != nil {
			返回_错误 = err
			return
		}
		返回_错误 = json.Unmarshal([]byte(JSON), &类.原始数据)
		return
	}

}

func (类 *S数组_文本) Q取数量() int {
	return len(类.原始数据)
}
func (类 *S数组_文本) Q取切片() (文本切片 []string) {
	文本切片 = make([]string, 0)
	if 类.读写许可 != nil {
		类.读写许可.RLock()
		defer 类.读写许可.RUnlock()
	}
	文本切片 = make([]string, len(类.原始数据))
    copy(文本切片, 类.原始数据)
	return 文本切片
}

func (类 *S数组_文本) Q清空() bool {
	if 类.读写许可 != nil {
		类.读写许可.Lock()
		defer 类.读写许可.Unlock()
	}
	类.原始数据 = make([]string, 0)
	return true
}

// 列分割符 会将 数据分割成 []any  加了表分割符 会分割成[]map[string]any
func (类 *S数组_文本) C从文本分割(文本 string, 分割符 string) (返回_错误 error) {
	if 类.读写许可 != nil {
		类.读写许可.Lock()
		defer 类.读写许可.Unlock()
	}
	类.初始化()
	类.原始数据 = make([]string, 0)
	分割组 := 全_文本.F分割文本(文本, 分割符)
	类.原始数据 = append(类.原始数据, 分割组...)
	return
}

func (类 *S数组_文本) D到JSON() (返回_值 string) {
	if 类.读写许可 != nil {
		类.读写许可.RLock()
		defer 类.读写许可.RUnlock()
	}
	类.初始化()
	JSON, err := json.Marshal(类.原始数据)
	if err != nil {
		返回_值 = "[]"
		return
	}
	返回_值 = string(JSON)
	return
}

func (类 *S数组_文本) D到新数组_文本() (返回_值 S数组_文本) {
	返回_值.Q清空()
	类.初始化()
	if 类.读写许可 != nil {
		if &类.读写许可 == &返回_值.读写许可 {
			return
		}
		类.读写许可.RLock()
		defer 类.读写许可.RUnlock()
	}
	返回_值.ZR载入(类.原始数据)
	return
}

func (类 *S数组_文本) Q取值(索引 int) (返回_值 string, 返回_错误 error) {
	if 类.读写许可 != nil {
		类.读写许可.RLock()
		defer 类.读写许可.RUnlock()
	}
	类.初始化()
	if 索引 >= len(类.原始数据) {
		返回_错误 = errors.New("取值位置超过数组长度")
		return
	}
	返回_值 = 类.原始数据[索引]
	return
}
func (类 *S数组_文本) Z置值(添加值 string, 索引 int) (返回_错误 error) {
	类.初始化()
	if 类.读写许可 != nil {
		类.读写许可.Lock()
		defer 类.读写许可.Unlock()
	}
	if 索引 >= len(类.原始数据) || 索引<0 {
		返回_错误 = errors.New("删除置值位置超过数组范围")
		return
	}
	类.原始数据[索引] = 添加值
	return
}

func (类 *S数组_文本) ZR载入_重文件(文件路径 string) (返回_错误 error) {
	var data []byte
	data, 返回_错误 = 全_文件.D读入_文件(文件路径)
	if 返回_错误 != nil {
		return
	}
	类.初始化()
	if 类.读写许可 != nil {
		类.读写许可.Lock()
		defer 类.读写许可.Unlock()
	}
	返回_错误 = json.Unmarshal(data, &类.原始数据)
	if 返回_错误 != nil {
		return
	}
	return
}

func (类 *S数组_文本) B保存_到文件(文件路径 string) (返回_错误 error) {
	类.初始化()
	if 类.读写许可 != nil {
		类.读写许可.RLock()
		defer 类.读写许可.RUnlock()
	}
	JSON, err := json.Marshal(类.原始数据)
	if err != nil {
		返回_错误 = err
		return
	}
	返回_错误 = 全_文件.X写到_文件(文件路径, []byte(JSON))
	return
}

// 单个 或 按顺序 连续添加
func (类 *S数组_文本) T添加值(添加值 ...string) {

	类.初始化()
	if 类.读写许可 != nil {
		类.读写许可.Lock()
		defer 类.读写许可.Unlock()
	}
	类.原始数据 = append(类.原始数据, 添加值...)
	
}

func (类 *S数组_文本) S删除值(被删除值 string)  {
	类.初始化()
	if 类.读写许可 != nil {
		类.读写许可.Lock()
		defer 类.读写许可.Unlock()
	}
	新值 :=make([]string,0)
	for _, v := range 类.原始数据 {
		if v ==被删除值{
			continue
		}
		新值=append(新值, v)
	}
	类.原始数据 = 新值
}

func (类 *S数组_文本) S删除值_按位置(被删除位置 int) (返回_错误 error) {
	类.初始化()
	if 类.读写许可 != nil {
		类.读写许可.Lock()
		defer 类.读写许可.Unlock()
	}
	if 被删除位置 >= len(类.原始数据) || 被删除位置<0 {
		返回_错误 = errors.New("删除置值位置超过数组范围")
		return
	}
	类.原始数据=append(类.原始数据[:被删除位置],类.原始数据[被删除位置+1:]... )
	return
}

func (类 *S数组_文本) C查询_包含(包含值 string) (返回_数组_文本 S数组_文本, 返回_错误 error) {
	返回_数组_文本.Q清空()
	类.初始化()
	if 类.读写许可 != nil {
		类.读写许可.RLock()
		defer 类.读写许可.RUnlock()
	}
	for _, v := range 类.原始数据 {
		if 全_文本.P判断存在(v, 包含值) {
			返回_数组_文本.T添加值(v)
		}

	}
	return

}

func (类 *S数组_文本) C查找(查找内容 string, 开始位置 ...int) (返回_位置 int) {
	判断开始位置 := 0
	返回_位置 = -1
	if len(开始位置) > 0 {
		判断开始位置 = 开始位置[0]
	}
	if 类.读写许可 != nil {
		类.读写许可.RLock()
		defer 类.读写许可.RUnlock()
	}
	for i, v := range 类.原始数据 {
		if i >= 判断开始位置 && v == 查找内容 {
			return i

		}
	}
	return
}

func (类 *S数组_文本) C查找_位置组(查找内容 string) (返回_位置 []int) {
	返回_位置 = make([]int, 0)
	if 类.读写许可 != nil {
		类.读写许可.RLock()
		defer 类.读写许可.RUnlock()
	}
	for i, v := range 类.原始数据 {
		if v == 查找内容 {
			返回_位置 = append(返回_位置, i)

		}
	}
	return
}

func (类 *S数组_文本) L连接到文本(合并连接符 string) (返回_值 string) {
	类.初始化()
	if 类.读写许可 != nil {
		类.读写许可.RLock()
		defer 类.读写许可.RUnlock()
	}
	返回_值 = strings.Join(类.原始数据, 合并连接符)
	return
}

func (类 *S数组_文本) H合并数组(数组_文本 S数组_文本) {
	类.初始化()
	if 类.读写许可 != nil {
		类.读写许可.Lock()
		defer 类.读写许可.Unlock()
	}
	类.原始数据 = append(类.原始数据, 数组_文本.Q取切片()...)
}

// 把其它列表的值合并成一个 新的返回列表  相同的会被替换, 没有的会添加进来(不影响原列表 )
func (类 *S数组_文本) H合并数组_到新数组(参数列表 S数组_文本) (返回列表 S数组_文本, 返回错误 error) {
	if &返回列表.原始数据 == &类.原始数据 || &返回列表.原始数据 == &参数列表.原始数据 {
		返回错误 = errors.New("新列表 不能是原有列表")
		return
	}
	类.初始化()
	if 类.读写许可 != nil {
		类.读写许可.Lock()
		defer 类.读写许可.Unlock()
	}
	返回列表.ZR载入(类.原始数据)
	返回列表.H合并数组(参数列表)
	return
}

// @键参数 排序条件的键  如果键参数="" 则按整切片排序
// @ 排序类型 1=文本 2=整数 3=浮点数 其他数 默认 文本
func (类 *S数组_文本) P排序( 排序类型 int, 是否升序 bool) (返回错误 error) {
	if 排序类型 != 2 && 排序类型 != 3 {
		排序类型 = 1
	}
	类.初始化()
	if 类.读写许可 != nil {
		类.读写许可.Lock()
		defer 类.读写许可.Unlock()
	}

	sort.SliceStable(类.原始数据, func(i, j int) bool {
			前数据 := 类.原始数据[i]
			后数据 := 类.原始数据[j]
			if 排序类型 == 2 {
				值1 := 全_类型.D到整数(前数据)
				值2 := 全_类型.D到整数(后数据)
				if 是否升序 {
					return 值1 < 值2
				} else {
					return 值1 > 值2
				}

			} else if 排序类型 == 3 {
				值1 := 全_类型.D到双精度小数(前数据)
				值2 := 全_类型.D到双精度小数(后数据)
				if 是否升序 {
					return 值1 < 值2
				} else {
					return 值1 > 值2
				}

			} else {
				值1 := 全_类型.D到文本(前数据)
				值2 := 全_类型.D到文本(后数据)
				if 是否升序 {
					return 值1 < 值2
				} else {
					return 值1 > 值2
				}

			}

	})

	return
}

func (类 *S数组_文本) Q去重复() {
	类.初始化()
	if 类.读写许可 != nil {
		类.读写许可.Lock()
		defer 类.读写许可.Unlock()
	}
	var 数组 S数组_文本
	for _, v := range 类.原始数据 {
		if 数组.C查找(v)<0{
			数组.T添加值(v)
		}
	}
	类.原始数据=数组.Q取切片()
}
